
/******************************************************************

    iLBC Speech Coder ANSI-C Source Code

    iLBC_encode.c 

    Copyright (C) The Internet Society (2004). 
    All Rights Reserved.

******************************************************************/

#include <math.h>
#include <stdlib.h>
#include <string.h>

#include "iLBC_define.h"
#include "iLBC_encode.h"
#include "LPCencode.h"
#include "FrameClassify.h"
#include "StateSearchW.h"
#include "StateConstructW.h"
#include "helpfun.h"
#include "constants.h"
#include "packing.h"
#include "iCBSearch.h"
#include "iCBConstruct.h"
#include "hpInput.h"
#include "anaFilter.h"
#include "syntFilter.h"

/*----------------------------------------------------------------*
 *  Initiation of encoder instance.
 *---------------------------------------------------------------*/

short initEncode(                   /* (o) Number of bytes 
                                           encoded */
    iLBC_Enc_Inst_t *iLBCenc_inst,  /* (i/o) Encoder instance */
    int mode                    /* (i) frame size mode */
){
    iLBCenc_inst->mode = mode;
    if (mode==30) {
        iLBCenc_inst->blockl = BLOCKL_30MS;
        iLBCenc_inst->nsub = NSUB_30MS;


        iLBCenc_inst->nasub = NASUB_30MS;
        iLBCenc_inst->lpc_n = LPC_N_30MS;
        iLBCenc_inst->no_of_bytes = NO_OF_BYTES_30MS;
        iLBCenc_inst->no_of_words = NO_OF_WORDS_30MS;
        iLBCenc_inst->state_short_len=STATE_SHORT_LEN_30MS;
        /* ULP init */
        iLBCenc_inst->ULP_inst=&ULP_30msTbl;
    }
    else if (mode==20) {
        iLBCenc_inst->blockl = BLOCKL_20MS;
        iLBCenc_inst->nsub = NSUB_20MS;
        iLBCenc_inst->nasub = NASUB_20MS;
        iLBCenc_inst->lpc_n = LPC_N_20MS;
        iLBCenc_inst->no_of_bytes = NO_OF_BYTES_20MS;
        iLBCenc_inst->no_of_words = NO_OF_WORDS_20MS;
        iLBCenc_inst->state_short_len=STATE_SHORT_LEN_20MS;
        /* ULP init */
        iLBCenc_inst->ULP_inst=&ULP_20msTbl;
    }
    else {
        exit(2);
    }

    memset((*iLBCenc_inst).anaMem, 0, 
        LPC_FILTERORDER*sizeof(float));
    memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl,
        LPC_FILTERORDER*sizeof(float));
    memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl,
        LPC_FILTERORDER*sizeof(float));
    memset((*iLBCenc_inst).lpc_buffer, 0, 
        (LPC_LOOKBACK+BLOCKL_MAX)*sizeof(float));
    memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float));

    return (iLBCenc_inst->no_of_bytes);
}

/*----------------------------------------------------------------*
 *  main encoder function 
 *---------------------------------------------------------------*/

void iLBC_encode(
    unsigned char *bytes,           /* (o) encoded data bits iLBC */
    float *block,                   /* (o) speech vector to 
                                           encode */
    iLBC_Enc_Inst_t *iLBCenc_inst   /* (i/o) the general encoder 
                                           state */
){
    
    float data[BLOCKL_MAX];
    float residual[BLOCKL_MAX], reverseResidual[BLOCKL_MAX];

    int start, idxForMax, idxVec[STATE_LEN];
    float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML];
    int n, k, meml_gotten, Nfor, Nback, i, pos;


    int gain_index[CB_NSTAGES*NASUB_MAX], 
        extra_gain_index[CB_NSTAGES];
    int cb_index[CB_NSTAGES*NASUB_MAX],extra_cb_index[CB_NSTAGES];
    int lsf_i[LSF_NSPLIT*LPC_N_MAX];
    unsigned char *pbytes;
    int diff, start_pos, state_first;
    float en1, en2;
    int index, ulp, firstpart;
    int subcount, subframe;
    float weightState[LPC_FILTERORDER];
    float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)]; 
    float weightdenum[NSUB_MAX*(LPC_FILTERORDER+1)]; 
    float decresidual[BLOCKL_MAX];

    /* high pass filtering of input signal if such is not done 
           prior to calling this function */

    hpInput(block, iLBCenc_inst->blockl, 
                data, (*iLBCenc_inst).hpimem);

    /* otherwise simply copy */

    /*memcpy(data,block,iLBCenc_inst->blockl*sizeof(float));*/
        
    /* LPC of hp filtered input data */

    LPCencode(syntdenum, weightdenum, lsf_i, data, iLBCenc_inst);


    /* inverse filter to get residual */

    for (n=0; n<iLBCenc_inst->nsub; n++) {
        anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)], 
            SUBL, &residual[n*SUBL], iLBCenc_inst->anaMem);
    }

    /* find state location */

    start = FrameClassify(iLBCenc_inst, residual);
    
    /* check if state should be in first or last part of the 
    two subframes */

    diff = STATE_LEN - iLBCenc_inst->state_short_len;
    en1 = 0;
    index = (start-1)*SUBL;
    for (i = 0; i < iLBCenc_inst->state_short_len; i++) {
        en1 += residual[index+i]*residual[index+i];
    }
    en2 = 0;
    index = (start-1)*SUBL+diff;
    for (i = 0; i < iLBCenc_inst->state_short_len; i++) {
        en2 += residual[index+i]*residual[index+i];
    }


    
    
    if (en1 > en2) {
        state_first = 1;
        start_pos = (start-1)*SUBL;
    } else {
        state_first = 0;
        start_pos = (start-1)*SUBL + diff;
    }

    /* scalar quantization of state */

    StateSearchW(iLBCenc_inst, &residual[start_pos], 
        &syntdenum[(start-1)*(LPC_FILTERORDER+1)], 
        &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax, 
        idxVec, iLBCenc_inst->state_short_len, state_first);

    StateConstructW(idxForMax, idxVec, 
        &syntdenum[(start-1)*(LPC_FILTERORDER+1)], 
        &decresidual[start_pos], iLBCenc_inst->state_short_len);

    /* predictive quantization in state */
    
    if (state_first) { /* put adaptive part in the end */
        
        /* setup memory */

        memset(mem, 0, 
            (CB_MEML-iLBCenc_inst->state_short_len)*sizeof(float));
        memcpy(mem+CB_MEML-iLBCenc_inst->state_short_len, 
            decresidual+start_pos, 
            iLBCenc_inst->state_short_len*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

        /* encode sub-frames */

        iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index, 
            &residual[start_pos+iLBCenc_inst->state_short_len], 
            mem+CB_MEML-stMemLTbl,
            stMemLTbl, diff, CB_NSTAGES, 
            &weightdenum[start*(LPC_FILTERORDER+1)], 
            weightState, 0);

        /* construct decoded vector */

        iCBConstruct(
            &decresidual[start_pos+iLBCenc_inst->state_short_len],
            extra_cb_index, extra_gain_index, 
            mem+CB_MEML-stMemLTbl, 
            stMemLTbl, diff, CB_NSTAGES);
    
    } 
    else { /* put adaptive part in the beginning */
        


        /* create reversed vectors for prediction */

        for (k=0; k<diff; k++) {
            reverseResidual[k] = residual[(start+1)*SUBL-1
                -(k+iLBCenc_inst->state_short_len)];
        }
        
        /* setup memory */

        meml_gotten = iLBCenc_inst->state_short_len;
        for (k=0; k<meml_gotten; k++) { 
            mem[CB_MEML-1-k] = decresidual[start_pos + k];
        } 
        memset(mem, 0, (CB_MEML-k)*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));
        
        /* encode sub-frames */

        iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index, 
            reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl, 
            diff, CB_NSTAGES, 
            &weightdenum[(start-1)*(LPC_FILTERORDER+1)], 
            weightState, 0);

        /* construct decoded vector */

        iCBConstruct(reverseDecresidual, extra_cb_index, 
            extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl, 
            diff, CB_NSTAGES);
        
        /* get decoded residual from reversed vector */

        for (k=0; k<diff; k++) {
            decresidual[start_pos-1-k] = reverseDecresidual[k];
        }
    }

    /* counter for predicted sub-frames */

    subcount=0;

    /* forward prediction of sub-frames */

    Nfor = iLBCenc_inst->nsub-start-1;

    
    if ( Nfor > 0 ) {
        
        /* setup memory */

        memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
        memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL, 
            STATE_LEN*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));



        /* loop over sub-frames to encode */

        for (subframe=0; subframe<Nfor; subframe++) {

            /* encode sub-frame */

            iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                &residual[(start+1+subframe)*SUBL], 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES, 
                &weightdenum[(start+1+subframe)*
                            (LPC_FILTERORDER+1)],
                weightState, subcount+1);

            /* construct decoded vector */

            iCBConstruct(&decresidual[(start+1+subframe)*SUBL], 
                cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES);

            /* update memory */

            memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
            memcpy(mem+CB_MEML-SUBL, 
                &decresidual[(start+1+subframe)*SUBL], 
                SUBL*sizeof(float));
            memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

            subcount++;
        }
    }
    

    /* backward prediction of sub-frames */

    Nback = start-1;

    
    if ( Nback > 0 ) {
               
        /* create reverse order vectors */

        for (n=0; n<Nback; n++) {
            for (k=0; k<SUBL; k++) {
                reverseResidual[n*SUBL+k] = 
                    residual[(start-1)*SUBL-1-n*SUBL-k];
                reverseDecresidual[n*SUBL+k] = 
                    decresidual[(start-1)*SUBL-1-n*SUBL-k];
            }
        }



        /* setup memory */

        meml_gotten = SUBL*(iLBCenc_inst->nsub+1-start);

        
        if ( meml_gotten > CB_MEML ) { 
            meml_gotten=CB_MEML;
        }
        for (k=0; k<meml_gotten; k++) { 
            mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
        } 
        memset(mem, 0, (CB_MEML-k)*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

        /* loop over sub-frames to encode */

        for (subframe=0; subframe<Nback; subframe++) {
            
            /* encode sub-frame */

            iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                &reverseResidual[subframe*SUBL], 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES, 
                &weightdenum[(start-2-subframe)*
                            (LPC_FILTERORDER+1)], 
                weightState, subcount+1);

            /* construct decoded vector */

            iCBConstruct(&reverseDecresidual[subframe*SUBL], 
                cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES);

            /* update memory */

            memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
            memcpy(mem+CB_MEML-SUBL, 
                &reverseDecresidual[subframe*SUBL],
                SUBL*sizeof(float));
            memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

            subcount++;

        }

        /* get decoded residual from reversed vector */

        for (i=0; i<SUBL*Nback; i++) {
            decresidual[SUBL*Nback - i - 1] = 


                reverseDecresidual[i];
        }
    }
    /* end encoding part */

    /* adjust index */
    index_conv_enc(cb_index);

    /* pack bytes */

    pbytes=bytes;
    pos=0;

    /* loop over the 3 ULP classes */

    for (ulp=0; ulp<3; ulp++) {
    
        /* LSF */
        for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_n; k++) {
            packsplit(&lsf_i[k], &firstpart, &lsf_i[k], 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos);
        }

        /* Start block info */

        packsplit(&start, &firstpart, &start, 
            iLBCenc_inst->ULP_inst->start_bits[ulp], 
            iLBCenc_inst->ULP_inst->start_bits[ulp]+
            iLBCenc_inst->ULP_inst->start_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->start_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->start_bits[ulp], &pos);

        packsplit(&state_first, &firstpart, &state_first, 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp], 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos);

        packsplit(&idxForMax, &firstpart, &idxForMax, 
            iLBCenc_inst->ULP_inst->scale_bits[ulp], 
            iLBCenc_inst->ULP_inst->scale_bits[ulp]+
            iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->scale_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos);



        for (k=0; k<iLBCenc_inst->state_short_len; k++) {
            packsplit(idxVec+k, &firstpart, idxVec+k, 
                iLBCenc_inst->ULP_inst->state_bits[ulp], 
                iLBCenc_inst->ULP_inst->state_bits[ulp]+
                iLBCenc_inst->ULP_inst->state_bits[ulp+1]+
                iLBCenc_inst->ULP_inst->state_bits[ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->state_bits[ulp], &pos);
        }

        /* 23/22 (20ms/30ms) sample block */

        for (k=0;k<CB_NSTAGES;k++) {
            packsplit(extra_cb_index+k, &firstpart, 
                extra_cb_index+k, 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], 
                &pos);
        }

        for (k=0;k<CB_NSTAGES;k++) {
            packsplit(extra_gain_index+k, &firstpart, 
                extra_gain_index+k, 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], 
                &pos);
        }
            
        /* The two/four (20ms/30ms) 40 sample sub-blocks */

        for (i=0; i<iLBCenc_inst->nasub; i++) {
            for (k=0; k<CB_NSTAGES; k++) {
                packsplit(cb_index+i*CB_NSTAGES+k, &firstpart, 
                    cb_index+i*CB_NSTAGES+k, 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]);
                dopack( &pbytes, firstpart, 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], 
                    &pos);
            }
        }
        
        for (i=0; i<iLBCenc_inst->nasub; i++) {
            for (k=0; k<CB_NSTAGES; k++) {


                packsplit(gain_index+i*CB_NSTAGES+k, &firstpart, 
                    gain_index+i*CB_NSTAGES+k, 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]);
                dopack( &pbytes, firstpart, 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], 
                    &pos);
            }
        }
    }

    /* set the last bit to zero (otherwise the decoder 
       will treat it as a lost frame) */
    dopack( &pbytes, 0, 1, &pos);
}



